const express = require('express');
const multer = require('multer');
const sqlite3 = require('sqlite3').verbose();
const path = require('path');
const bodyParser = require('body-parser');
const fs = require('fs');
const bcrypt = require('bcrypt');

const app = express();
const upload = multer({ dest: 'uploads/' });
const db = new sqlite3.Database(':memory:');

// 初始化数据库
db.serialize(() => {
    db.run("CREATE TABLE users (username TEXT, password TEXT, rootdir TEXT)");
    // 为每个用户设置不同的根目录
    const hashedPassword = bcrypt.hashSync('ddd', 10);
    db.run("INSERT INTO users (username, password, rootdir) VALUES ('zs', ?, ?)", [hashedPassword, path.join(__dirname, 'uploads', 'zs')]);
    db.run("INSERT INTO users (username, password, rootdir) VALUES ('ls', ?, ?)", [hashedPassword, path.join(__dirname, 'uploads', 'ls')]);
});

// 中间件
app.use(bodyParser.json());

// 用户当前目录状态
const userDirectories = {}; // 存储每个用户的当前目录

// 用户身份验证
app.post('/login', (req, res) => {
    const { username, password } = req.body;
    db.get("SELECT * FROM users WHERE username = ?", [username], (err, row) => {
        if (err || !row || !bcrypt.compareSync(password, row.password)) {
            return res.status(401).json({ message: '身份验证失败' });
        }
        // 设置用户的当前目录为数据库中保存的根目录
        userDirectories[username] = row.rootdir;
        // 确保用户目录存在
        if (!fs.existsSync(userDirectories[username])) {
            fs.mkdirSync(userDirectories[username], { recursive: true });
        }
        res.json({ message: '身份验证成功', user: username, currentDir: userDirectories[username] }); // 返回当前目录
    });
});

// 上传文件
app.post('/upload', upload.single('file'), (req, res) => {
    if (!req.file) {
        return res.status(400).json({ message: '没有文件上传' });
    }

    const username = req.body.username; // 从请求体中获取用户名
    if (!username) {
        return res.status(400).json({ message: '用户名未提供' });
    }

    const userDir = userDirectories[username]; // 使用用户的当前目录
    const filePath = path.join(userDir, req.file.originalname);

    fs.rename(req.file.path, filePath, (err) => {
        if (err) {
            return res.status(500).json({ message: '文件保存失败' });
        }
        res.json({ message: '文件上传成功' });
    });
});

// 下载文件
app.get('/download/:username/:filename', (req, res) => {
    const filePath = path.join(userDirectories[req.params.username], req.params.filename);
    res.download(filePath, (err) => {
        if (err) {
            res.status(404).send('文件未找到');
        }
    });
});

// 列出当前目录文件
app.get('/list/:username', (req, res) => {
    const userDir = userDirectories[req.params.username];

    if (!fs.existsSync(userDir)) {
        return res.status(404).json({ message: '用户目录不存在' });
    }

    fs.readdir(userDir, (err, files) => {
        if (err) {
            return res.status(500).json({ message: '无法读取目录' });
        }
        // 过滤出文件和目录，并在目录名后面添加 '/'
        const filesWithDirsMarked = files.map(file => {
            const fullPath = path.join(userDir, file);
            return fs.statSync(fullPath).isDirectory() ? file + '/' : file; // 保持原有功能
        });
        res.json(filesWithDirsMarked);
    });
});

// 删除文件或目录
app.delete('/delete/:username/*', (req, res) => {
    const nameToDelete = req.params[0];
    const userDir = path.join(userDirectories[req.params.username], nameToDelete);

    fs.stat(userDir, (err, stats) => {
        if (err) {
            return res.status(404).json({ message: '文件或目录未找到' });
        }
        if (stats.isDirectory()) {
            fs.rm(userDir, { recursive: true, force: true }, (err) => {
                if (err) {
                    return res.status(500).json({ message: '目录删除失败' });
                }
                res.json({ message: '目录删除成功' });
            });
        } else {
            fs.unlink(userDir, (err) => {
                if (err) {
                    return res.status(404).json({ message: '文件未找到' });
                }
                res.json({ message: '文件删除成功' });
            });
        }
    });
});

// 重命名文件
app.post('/rename/:username', (req, res) => {
    const { oldName, newName } = req.body;
    const oldPath = path.join(userDirectories[req.params.username], oldName);
    const newPath = path.join(userDirectories[req.params.username], newName);

    fs.rename(oldPath, newPath, (err) => {
        if (err) {
            return res.status(404).json({ message: '文件未找到或重命名失败' });
        }
        res.json({ message: '文件重命名成功' });
    });
});

// 创建目录
app.post('/mkdir/:username', (req, res) => {
    const dirName = req.body.dir;
    const dirPath = path.join(userDirectories[req.params.username], dirName);

    fs.mkdir(dirPath, { recursive: true }, (err) => {
        if (err) {
            return res.status(500).json({ message: '目录创建失败' });
        }
        res.json({ message: '目录创建成功' });
    });
});

// 修改服务器当前目录
app.post('/rcd/:username', (req, res) => {
    const newDir = req.body.dir; // 获取请求体中的新目录
    const userDirectory = userDirectories[req.params.username]; // 获取用户的当前根目录

    let userDir;

    // 判断输入的路径是否是绝对路径
    if (path.isAbsolute(newDir)) {
        userDir = newDir; // 如果是绝对路径，直接使用
    } else {
        userDir = path.join(userDirectory, newDir); // 否则将用户根目录与新目录合并
    }

    // 规范化路径
    const absolutePath = path.resolve(userDir); // 获取绝对路径

    // 检查该路径是否存在
    if (!fs.existsSync(absolutePath)) {
        return res.status(404).json({ message: '目录不存在' });
    }

    userDirectories[req.params.username] = absolutePath; // 更新用户的当前目录
    // res.json({ message: `服务器当前目录已更改为: ${absolutePath}` });
    res.json({ message: `服务器当前目录已更改成功` });
});

// 打印服务器当前目录
app.get('/rpwd/:username', (req, res) => {
    const userDir = userDirectories[req.params.username];
    const absolutePath = path.resolve(userDir); // 获取绝对路径
    res.json({ path: absolutePath }); // 返回当前目录的绝对路径
});

// 启动服务器
const PORT = 8080;
app.listen(PORT, () => {
    console.log(`服务器正在运行在 http://localhost:${PORT}`);
});